Fp16 constant weights - #3015

`_gen_value` printed the initializer with the printer's default dtype
rather than the Array's, which stamped a `float` suffix onto the entries
of a `double` Array and silently rounded them to single precision.

Route it through a new `initvalue` printer hook, which also gives the
targets a place to specialize an initializer whose type cannot be built
from a plain literal.

`_prec` floors an untyped real literal at `float32` so that an integer
default doesn't degrade the arithmetic around it. That floor also caught
`float16`, which is never a fallback but an explicit request, so every
literal in a half-precision Operator printed one type too wide.

Only apply the floor when the default is not already a real type.

The stability check sums the whole field and asks whether the result is
finite. The accumulator took the field's own dtype, so in half precision
it overflowed within a few thousand points and reported an instability
that wasn't there -- making `errctl=max`, the very option one reaches for
to diagnose a suspected instability, unusable exactly where it is needed.

Give it at least single precision.

A real literal in an otherwise integer expression is emitted at the
Operator's precision, floored at `float32` so that an integer default
does not degrade it. An Operator working in half wants that floor most
of the time -- half is a storage format, and the accuracy of the
literals is worth more than the width of the multiply -- but not always.

Give the printer a flag for it, off by default, and have `_printer`
pick up a Target's second printer where one is offered.

The same coefficients at two precisions are two different arrays, but
neither `__eq__` nor `_hashable_content` looked at the dtype, so the
first one built answered for both. An Operator asking for its weights in
one precision would be handed whichever an earlier Operator had cached.

Compare and hash on it. The name goes in rather than the type itself,
which does not order and so cannot be sorted alongside the rest.

Whether an Operator working in half also computes in half decides what
is calculated, not how quickly: the literals and the FD coefficients are
rounded to three decimal digits. That is a mathematical choice, so it
belongs with `interp-mode` in `sym_opt` rather than among the codegen
options, and is validated and defaulted alongside it.